// // package com.example.everying.utils;


// // import com.aliyun.oss.OSS;
// // import com.aliyun.oss.OSSClientBuilder;
// // import com.aliyun.oss.model.PutObjectRequest;
// // import com.aliyuncs.DefaultAcsClient;
// // import com.aliyuncs.IAcsClient;
// // import com.aliyuncs.http.FormatType;
// // import com.aliyuncs.http.HttpResponse;
// // import com.aliyuncs.profile.DefaultProfile;
// // import lombok.extern.slf4j.Slf4j;
// // import org.springframework.beans.factory.annotation.Autowired;
// // import org.springframework.beans.factory.annotation.Value;
// // import org.springframework.context.annotation.PropertySource;
// // import org.springframework.stereotype.Service;
// // import org.springframework.web.multipart.MultipartFile;

// // import java.io.IOException;
// // import java.util.ArrayList;
// // import java.util.List;
// // import java.util.UUID;

// // import com.aliyuncs.green.model.v20180509.ImageSyncScanRequest;
// // import com.alibaba.fastjson.JSON;
// // import com.alibaba.fastjson.JSONArray;
// // import com.alibaba.fastjson.JSONObject;

// // import java.util.Arrays;

// // import com.aliyuncs.http.MethodType;
// // import com.aliyuncs.http.ProtocolType;

// // import java.util.Date;

// // /**
// //  * @program: everything
// //  * @description: 图片配置
// //  * @author: zw
// //  * @create: 2025-05-16 16:56
// //  **/
// // @Slf4j
// // @Service
// // @PropertySource("classpath:application.yaml")
// // public class ImageUpload {

// //     @Value("${aliyun.oss.endpoint}")
// //     private String endpoint = "oss-cn-beijing.aliyuncs.com";
// //     @Value("${aliyun.oss.accessKeyId}")
// //     private String accessKeyId = "LTAI5t8SaRP7na1rPDp2HRjp";
// //     @Value("${aliyun.oss.accessKeySecret}")
// //     private String accessKeySecret = "5pWa2XgR69iPAFTTknSFfVjD4XqQ13";
// //     @Value("${aliyun.oss.bucketName}")
// //     private String bucketName = "everything-dev-tuoyang";
// //     @Value("${aliyun.oss.urlPrefix}")
// //     private String urlPrefix = "https://everything-dev-tuoyang.oss-cn-beijing.aliyuncs.com";
// //     @Value("${aliyun.oss.maxSizeMB}")
// //     private long maxSizeMB = 20; // 单文件最大限制(MB)
// //     private final long maxSizeBytes;

// //     @Value("${aliyun.green.access-key-id}")
// //     private String greenAccessKeyId;

// //     @Value("${aliyun.green.access-key-secret}")
// //     private String greenAccessKeySecret;

// //     @Value("${aliyun.green.read-timeout:6000}")
// //     private int readTimeout;

// //     @Value("${aliyun.green.connect-timeout:3000}")
// //     private int connectTimeout;

// //     @Autowired
// //     private AliGreenModerationUtil aliGreenModerationUtil;

// //     @Autowired
// //     private AliVideoModerationUtil aliVideoModerationUtil;

// //     public ImageUpload() {
// //         this.maxSizeBytes = maxSizeMB * 1024 * 1024;
// //     }

// //     public List<String> uploadImages(MultipartFile[] files) throws IOException {
// //         if (files == null || files.length == 0) {
// //             return new ArrayList<>();
// //         }
// //         List<String> urls = new ArrayList<>(files.length);
// //         OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
// //         try {
// //             for (MultipartFile file : files) {
// //                 if (file == null || file.isEmpty()) {
// //                     continue;
// //                 }
// //                 // 校验文件大小
// //                 if (file.getSize() > maxSizeBytes) {
// //                     System.out.println("文件大小：" + file.getSize() + "====" + maxSizeBytes);
// //                     String message = "文件大小超过限制: " + maxSizeMB + "MB";
// //                     throw new CampusException(message, 201);
// //                 }
// //                 // 校验文件类型
// //                 String contentType = file.getContentType();
// //                 if (contentType == null || !isValidImageType(contentType)) {
// //                     String message = "无效的图片类型: " + contentType;
// //                     throw new CampusException(message,201);
// //                 }
// //                 // 生成唯一文件名
// //                 String fileName = generateUniqueFileName(file.getOriginalFilename());
// //                 String ossPath = "images/" + fileName;
// //                 // 上传到OSS
// //                 PutObjectRequest request = new PutObjectRequest(bucketName, ossPath, file.getInputStream());
// //                 ossClient.putObject(request);

// //                 String imageUrl = urlPrefix + "/" + ossPath;

// //                 if(contentType.startsWith("image/") &&
// //                         (contentType.endsWith("jpeg") ||
// //                                 contentType.endsWith("png") ||
// //                                 contentType.endsWith("gif") ||
// //                                 contentType.endsWith("webp") ||
// //                                 contentType.endsWith("bmp"))){
// //                     // 新增：图片安全审核
// // //                if (isImageSafe(imageUrl)) {
// //                     if (!aliGreenModerationUtil.containsProhibitedContent(imageUrl)) {
// //                         // 构建访问URL
// //                         urls.add(imageUrl);
// //                     } else {
// //                         // 审核不通过，删除违规图片
// //                         ossClient.deleteObject(bucketName, ossPath);
// //                         urls.remove(imageUrl);
// //                         log.warn("图片包含敏感内容已删除: {}", ossPath);
// //                         throw new CampusException("图片包含敏感内容", 201);

// //                     }
// //                 } else if (contentType.startsWith("video/") &&
// //                         (contentType.endsWith("mp4") ||
// //                                 contentType.endsWith("webm") ||
// //                                 contentType.endsWith("ogg") ||
// //                                 contentType.endsWith("quicktime") ||
// //                                 contentType.endsWith("x-msvideo"))){
// //                     if (aliVideoModerationUtil.checkVideo(imageUrl)){
// //                         urls.add(imageUrl);
// //                     }else {
// //                         // 审核不通过，删除违规图片
// //                         ossClient.deleteObject(bucketName, ossPath);
// //                         urls.remove(imageUrl);
// //                         log.warn("视频包含敏感内容已删除: {}", ossPath);
// //                         throw new CampusException("视频包含敏感内容", 201);
// //                     }

// //                     return urls;
// //                 }

// //             }
// //         } finally {
// //             ossClient.shutdown();
// //         }

// //         return urls;
// //     }

// //     private boolean isImageSafe(String imageUrl) {
// //         // 创建DefaultProfile实例
// //         DefaultProfile profile = DefaultProfile.getProfile(
// //                 "cn-beijing",  // 地域ID
// //                 greenAccessKeyId,     // AccessKey ID
// //                 greenAccessKeySecret  // AccessKey Secret
// //         );
// //         // 添加endpoint
// //         DefaultProfile.addEndpoint("cn-beijing", "Green", "green.cn-beijing.aliyuncs.com");
// //         // 创建IAcsClient实例
// //         IAcsClient client = new DefaultAcsClient(profile);

// //         try {
// //             // 创建同步扫描请求
// //             ImageSyncScanRequest imageSyncScanRequest = new ImageSyncScanRequest();
// //             imageSyncScanRequest.setAcceptFormat(FormatType.JSON);
// //             imageSyncScanRequest.setMethod(MethodType.POST);
// //             imageSyncScanRequest.setEncoding("utf-8");
// //             imageSyncScanRequest.setProtocol(ProtocolType.HTTP);

// //             // 构建请求体
// //             JSONObject httpBody = new JSONObject();
// //             // 设置要检测的场景，根据需要添加或删除场景
// //             httpBody.put("scenes", Arrays.asList(
// //                     "porn",      // 鉴黄
// //                     "terrorism", // 暴恐涉政
// //                     "ad",        // 广告
// //                     "qrcode",    // 二维码
// //                     "live",      // 不良场景
// //                     "logo"       // 商标台标
// //             ));

// //             // 设置待检测图片
// //             JSONObject task = new JSONObject();
// //             task.put("dataId", UUID.randomUUID().toString());
// //             task.put("url", imageUrl);
// //             task.put("time", new Date());
// //             httpBody.put("tasks", Arrays.asList(task));

// //             // 设置请求内容
// //             imageSyncScanRequest.setHttpContent(
// //                     org.apache.commons.codec.binary.StringUtils.getBytesUtf8(httpBody.toJSONString()),
// //                     "UTF-8",
// //                     FormatType.JSON
// //             );
// //             // 设置超时时间
// //             imageSyncScanRequest.setConnectTimeout(connectTimeout);
// //             imageSyncScanRequest.setReadTimeout(readTimeout);

// //             // 调用服务端进行图片审核
// //             HttpResponse httpResponse = client.doAction(imageSyncScanRequest);

// //             // 处理响应结果
// //             if (httpResponse.isSuccess()) {
// //                 JSONObject scrResponse = JSON.parseObject(new String(httpResponse.getHttpContent(), "UTF-8"));
// //                 JSONArray taskResults = scrResponse.getJSONArray("data");

// //                 if (taskResults != null && !taskResults.isEmpty()) {
// //                     JSONObject taskResult = taskResults.getJSONObject(0);
// //                     // 这里不应该把200当作错误，200是正常的响应码
// //                     if (taskResult.getInteger("code") == 200) {
// //                         JSONArray sceneResults = taskResult.getJSONArray("results");
// //                         // 遍历每个场景的检测结果
// //                         for (int i = 0; i < sceneResults.size(); i++) {
// //                             JSONObject sceneResult = sceneResults.getJSONObject(i);
// //                             String suggestion = sceneResult.getString("suggestion");
// //                             // 只有当建议为block时才记录警告日志
// //                             if ("block".equals(suggestion)) {
// //                                 log.warn("图片审核不通过，场景: {}, 建议: {}",
// //                                         sceneResult.getString("scene"),
// //                                         suggestion);
// //                                 return false;
// //                             }
// //                         }
// //                         // 所有场景都通过审核
// //                         log.info("图片审核通过");
// //                         return true;
// //                     } else {
// //                         // 非200状态码才是真正的错误
// //                         log.error("图片审核服务响应异常，状态码: {}", taskResult.getInteger("code"));
// //                         return false;
// //                     }
// //                 }
// //             }
// //             // 如果请求失败或解析响应失败，为安全起见返回false
// //             log.error("图片审核请求失败: {}", httpResponse.getStatus());
// //             return false;
// //         } catch (Exception e) {
// //             log.error("图片审核异常", e);
// //             return false;
// //         }
// //     }

// //     private String generateUniqueFileName(String originalFilename) {
// //         String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
// //         return UUID.randomUUID().toString() + extension;
// //     }

// //     private boolean isValidImageType(String contentType) {
// //         return contentType.startsWith("image/") &&
// //                 (contentType.endsWith("jpeg") ||
// //                         contentType.endsWith("png") ||
// //                         contentType.endsWith("gif") ||
// //                         contentType.endsWith("webp") ||
// //                         contentType.endsWith("bmp"))
// //                 ||
// //                 contentType.startsWith("video/") &&
// //                         (contentType.endsWith("mp4") ||
// //                                 contentType.endsWith("webm") ||
// //                                 contentType.endsWith("ogg") ||
// //                                 contentType.endsWith("quicktime") ||
// //                                 contentType.endsWith("x-msvideo"));

// //     }

// // }


// package com.example.everying.utils;

// import com.aliyun.oss.OSS;
// import com.aliyun.oss.OSSClientBuilder;
// import com.aliyun.oss.model.PutObjectRequest;
// import com.aliyuncs.DefaultAcsClient;
// import com.aliyuncs.IAcsClient;
// import com.aliyuncs.http.FormatType;
// import com.aliyuncs.http.HttpResponse;
// import com.aliyuncs.profile.DefaultProfile;
// import lombok.extern.slf4j.Slf4j;
// import org.springframework.beans.factory.annotation.Autowired;
// import org.springframework.beans.factory.annotation.Value;
// import org.springframework.context.annotation.PropertySource;
// import org.springframework.stereotype.Service;
// import org.springframework.web.multipart.MultipartFile;

// import javax.imageio.ImageIO;
// import java.awt.*;
// import java.awt.image.BufferedImage;
// import java.io.*;
// import java.util.ArrayList;
// import java.util.List;
// import java.util.UUID;

// import com.aliyuncs.green.model.v20180509.ImageSyncScanRequest;
// import com.alibaba.fastjson.JSON;
// import com.alibaba.fastjson.JSONArray;
// import com.alibaba.fastjson.JSONObject;

// import java.util.Arrays;

// import com.aliyuncs.http.MethodType;
// import com.aliyuncs.http.ProtocolType;

// import java.util.Date;

// /**
//  * @program: everything
//  * @description: 图片配置
//  * @author: zw
//  * @create: 2025-05-16 16:56
//  **/
// @Slf4j
// @Service
// @PropertySource("classpath:application.yaml")
// public class ImageUpload {

//     @Value("${aliyun.oss.endpoint}")
//     private String endpoint = "oss-cn-beijing.aliyuncs.com";
//     @Value("${aliyun.oss.accessKeyId}")
//     private String accessKeyId = "LTAI5t8SaRP7na1rPDp2HRjp";
//     @Value("${aliyun.oss.accessKeySecret}")
//     private String accessKeySecret = "5pWa2XgR69iPAFTTknSFfVjD4XqQ13";
//     @Value("${aliyun.oss.bucketName}")
//     private String bucketName = "everything-dev-tuoyang";
//     @Value("${aliyun.oss.urlPrefix}")
//     private String urlPrefix = "https://everything-dev-tuoyang.oss-cn-beijing.aliyuncs.com";
//     @Value("${aliyun.oss.maxSizeMB}")
//     private long maxSizeMB = 20; // 单文件最大限制(MB)
//     private final long maxSizeBytes;

//     // 新增配置：最小文件大小阈值，小于此大小的图片将被稠密化
//     @Value("${aliyun.oss.minSizeMB:1}")
//     private long minSizeMB = 1; // 最小文件大小(MB)，默认1MB
//     private final long minSizeBytes;

//     @Value("${aliyun.green.access-key-id}")
//     private String greenAccessKeyId;

//     @Value("${aliyun.green.access-key-secret}")
//     private String greenAccessKeySecret;

//     @Value("${aliyun.green.read-timeout:6000}")
//     private int readTimeout;

//     @Value("${aliyun.green.connect-timeout:3000}")
//     private int connectTimeout;

//     @Autowired
//     private AliGreenModerationUtil aliGreenModerationUtil;

//     @Autowired
//     private AliVideoModerationUtil aliVideoModerationUtil;

//     public ImageUpload() {
//         this.maxSizeBytes = maxSizeMB * 1024 * 1024;
//         this.minSizeBytes = minSizeMB * 1024 * 1024;
//     }

//     public List<String> uploadImages(MultipartFile[] files) throws IOException {
//         if (files == null || files.length == 0) {
//             return new ArrayList<>();
//         }
//         List<String> urls = new ArrayList<>(files.length);
//         OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
//         try {
//             for (MultipartFile file : files) {
//                 if (file == null || file.isEmpty()) {
//                     continue;
//                 }
//                 // 校验文件大小
//                 if (file.getSize() > maxSizeBytes) {
//                     System.out.println("文件大小：" + file.getSize() + "====" + maxSizeBytes);
//                     String message = "文件大小超过限制: " + maxSizeMB + "MB";
//                     throw new CampusException(message, 201);
//                 }
                
//                 // 校验文件类型
//                 String contentType = file.getContentType();
//                 if (contentType == null || !isValidImageType(contentType)) {
//                     String message = "无效的图片类型: " + contentType;
//                     throw new CampusException(message, 201);
//                 }

//                 // 处理文件：如果是图片且小于最小大小阈值，进行稠密化处理
//                 MultipartFile processedFile = file;
//                 if (isImageFile(contentType) && file.getSize() < minSizeBytes) {
//                     log.info("图片大小为 {}KB，小于阈值 {}MB，开始稠密化处理", 
//                             file.getSize() / 1024, minSizeMB);
//                     processedFile = enhanceImageQuality(file);
//                     log.info("稠密化处理完成，新大小为 {}KB", processedFile.getSize() / 1024);
//                 }

//                 // 生成唯一文件名
//                 String fileName = generateUniqueFileName(processedFile.getOriginalFilename() != null ? 
//                         processedFile.getOriginalFilename() : file.getOriginalFilename());
//                 String ossPath = "images/" + fileName;
                
//                 // 上传到OSS
//                 PutObjectRequest request = new PutObjectRequest(bucketName, ossPath, processedFile.getInputStream());
//                 ossClient.putObject(request);

//                 String imageUrl = urlPrefix + "/" + ossPath;

//                 if (isImageFile(contentType)) {
//                     // 图片安全审核
//                     if (!aliGreenModerationUtil.containsProhibitedContent(imageUrl)) {
//                         urls.add(imageUrl);
//                     } else {
//                         // 审核不通过，删除违规图片
//                         ossClient.deleteObject(bucketName, ossPath);
//                         urls.remove(imageUrl);
//                         log.warn("图片包含敏感内容已删除: {}", ossPath);
//                         throw new CampusException("图片包含敏感内容", 201);
//                     }
//                 } else if (isVideoFile(contentType)) {
//                     // 视频审核
//                     if (aliVideoModerationUtil.checkVideo(imageUrl)) {
//                         urls.add(imageUrl);
//                     } else {
//                         // 审核不通过，删除违规视频
//                         ossClient.deleteObject(bucketName, ossPath);
//                         urls.remove(imageUrl);
//                         log.warn("视频包含敏感内容已删除: {}", ossPath);
//                         throw new CampusException("视频包含敏感内容", 201);
//                     }
//                 }
//             }
//         } finally {
//             ossClient.shutdown();
//         }

//         return urls;
//     }
//     /**
//      * 图片稠密化处理：将小图片放大并提高质量，确保文件大小超过阈值
//      */
//     private MultipartFile enhanceImageQuality(MultipartFile originalFile) throws IOException {
//         try {
//             // 读取原始图片
//             BufferedImage originalImage = ImageIO.read(originalFile.getInputStream());
//             if (originalImage == null) {
//                 log.warn("无法读取图片，使用原始文件");
//                 return originalFile;
//             }

//             int originalWidth = originalImage.getWidth();
//             int originalHeight = originalImage.getHeight();
//             long originalSize = originalFile.getSize();
            
//             log.info("原始图片尺寸: {}x{}, 大小: {}KB", originalWidth, originalHeight, originalSize / 1024);

//             // 目标文件大小：1.5MB（留有余量）
//             long targetSizeBytes = (long) (1.5 * 1024 * 1024);
            
//             // 计算需要的放大倍数（基于面积）
//             double targetSizeMB = targetSizeBytes / (1024.0 * 1024.0);
//             double currentSizeMB = originalSize / (1024.0 * 1024.0);
            
//             // 更激进的放大策略
//             double scaleFactor = Math.sqrt(targetSizeMB / currentSizeMB) * 1.8; // 增加1.8倍的缓冲
            
//             // 设置最小和最大缩放限制
//             scaleFactor = Math.max(scaleFactor, 2.0);  // 至少放大2倍
//             scaleFactor = Math.min(scaleFactor, 5.0);  // 最大放大5倍
            
//             int newWidth = (int) (originalWidth * scaleFactor);
//             int newHeight = (int) (originalHeight * scaleFactor);
            
//             log.info("计算缩放因子: {}, 目标尺寸: {}x{}", String.format("%.2f", scaleFactor), newWidth, newHeight);

//             // 尝试多种质量设置，直到达到目标大小
//             MultipartFile result = tryEnhanceWithDifferentQualities(originalImage, newWidth, newHeight, originalFile, targetSizeBytes);
            
//             // 如果还是达不到目标，尝试更大的尺寸
//             if (result.getSize() < targetSizeBytes) {
//                 log.info("第一次尝试大小不够，尝试更大尺寸...");
//                 newWidth = (int) (originalWidth * scaleFactor * 1.5);
//                 newHeight = (int) (originalHeight * scaleFactor * 1.5);
//                 result = tryEnhanceWithDifferentQualities(originalImage, newWidth, newHeight, originalFile, targetSizeBytes);
//             }

//             log.info("最终稠密化处理完成，新大小: {}KB", result.getSize() / 1024);
//             return result;

//         } catch (Exception e) {
//             log.error("图片稠密化处理失败，使用原始文件", e);
//             return originalFile;
//         }
//     }
//     private MultipartFile tryEnhanceWithDifferentQualities(BufferedImage originalImage, int newWidth, int newHeight, 
//                                                       MultipartFile originalFile, long targetSizeBytes) throws IOException {
    
//         // 尝试不同的质量设置，从高到低
//         float[] qualities = {1.0f, 0.98f, 0.95f, 0.92f, 0.90f};
        
//         for (float quality : qualities) {
//             try {
//                 MultipartFile enhanced = createEnhancedImage(originalImage, newWidth, newHeight, originalFile, quality);
                
//                 log.info("尝试质量 {}: 生成文件大小 {}KB", quality, enhanced.getSize() / 1024);
                
//                 // 如果达到目标大小，返回结果
//                 if (enhanced.getSize() >= targetSizeBytes) {
//                     log.info("✓ 达到目标大小，使用质量: {}", quality);
//                     return enhanced;
//                 }
                
//                 // 如果是最高质量但还是不够大，尝试添加噪点
//                 if (quality == 1.0f && enhanced.getSize() < targetSizeBytes) {
//                     log.info("最高质量仍不够，尝试添加细节...");
//                     MultipartFile withDetails = addImageDetails(originalImage, newWidth, newHeight, originalFile);
//                     if (withDetails.getSize() >= targetSizeBytes) {
//                         return withDetails;
//                     }
//                 }
                
//             } catch (Exception e) {
//                 log.warn("质量 {} 处理失败: {}", quality, e.getMessage());
//                 continue;
//             }
//         }
        
//         // 如果所有质量都达不到目标，返回最高质量的版本
//         return createEnhancedImage(originalImage, newWidth, newHeight, originalFile, 1.0f);
//     }

//     /**
//      * 创建增强图片
//      */
//     private MultipartFile createEnhancedImage(BufferedImage originalImage, int newWidth, int newHeight, 
//                                             MultipartFile originalFile, float quality) throws IOException {
        
//         // 创建高质量的缩放图片
//         BufferedImage enhancedImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
//         Graphics2D g2d = enhancedImage.createGraphics();
        
//         // 设置最高质量渲染参数
//         g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
//         g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
//         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
//         g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
//         g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
//         g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
        
//         // 绘制缩放后的图片
//         g2d.drawImage(originalImage, 0, 0, newWidth, newHeight, null);
//         g2d.dispose();

//         // 使用指定质量保存为JPEG
//         ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
//         // 创建JPEG写入器并设置质量
//         javax.imageio.ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
//         javax.imageio.ImageWriteParam param = writer.getDefaultWriteParam();
//         param.setCompressionMode(javax.imageio.ImageWriteParam.MODE_EXPLICIT);
//         param.setCompressionQuality(quality);
        
//         javax.imageio.stream.ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
//         writer.setOutput(ios);
//         writer.write(null, new javax.imageio.IIOImage(enhancedImage, null, null), param);
//         writer.dispose();
//         ios.close();
        
//         byte[] imageBytes = baos.toByteArray();
//         baos.close();

//         // 创建新的MultipartFile
//         return new EnhancedMultipartFile(
//                 imageBytes,
//                 originalFile.getName(),
//                 getEnhancedFileName(originalFile.getOriginalFilename()),
//                 "image/jpeg"
//         );
//     }
//     /**
//      * 生成增强后的文件名
//      */
//     private String getEnhancedFileName(String originalFilename) {
//         if (originalFilename == null) {
//             return UUID.randomUUID().toString() + "_enhanced.jpg";
//         }
        
//         int dotIndex = originalFilename.lastIndexOf('.');
//         if (dotIndex > 0) {
//             String nameWithoutExt = originalFilename.substring(0, dotIndex);
//             return nameWithoutExt + "_enhanced.jpg";
//         } else {
//             return originalFilename + "_enhanced.jpg";
//         }
//     }
//     /**
//      * 添加图片细节来增加文件大小
//      */
//     private MultipartFile addImageDetails(BufferedImage originalImage, int newWidth, int newHeight, 
//                                         MultipartFile originalFile) throws IOException {
        
//         // 创建更大尺寸的图片（再放大1.5倍）
//         int extraWidth = (int) (newWidth * 1.5);
//         int extraHeight = (int) (newHeight * 1.5);
        
//         BufferedImage detailedImage = new BufferedImage(extraWidth, extraHeight, BufferedImage.TYPE_INT_RGB);
//         Graphics2D g2d = detailedImage.createGraphics();
        
//         // 设置最高质量渲染
//         g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
//         g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
//         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        
//         // 绘制原图
//         g2d.drawImage(originalImage, 0, 0, extraWidth, extraHeight, null);
        
//         // 添加细微的纹理（增加文件复杂度）
//         addSubtleTexture(g2d, extraWidth, extraHeight);
        
//         g2d.dispose();

//         // 以最高质量保存
//         ByteArrayOutputStream baos = new ByteArrayOutputStream();
        
//         javax.imageio.ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
//         javax.imageio.ImageWriteParam param = writer.getDefaultWriteParam();
//         param.setCompressionMode(javax.imageio.ImageWriteParam.MODE_EXPLICIT);
//         param.setCompressionQuality(1.0f); // 最高质量
        
//         javax.imageio.stream.ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
//         writer.setOutput(ios);
//         writer.write(null, new javax.imageio.IIOImage(detailedImage, null, null), param);
//         writer.dispose();
//         ios.close();
        
//         byte[] imageBytes = baos.toByteArray();
//         baos.close();

//         log.info("添加细节后图片大小: {}KB", imageBytes.length / 1024);

//         return new EnhancedMultipartFile(
//                 imageBytes,
//                 originalFile.getName(),
//                 getEnhancedFileName(originalFile.getOriginalFilename()),
//                 "image/jpeg"
//         );
//     }
//     private void addSubtleTexture(Graphics2D g2d, int width, int height) {
//         // 创建非常细微的纹理，不影响图片观感但增加文件大小
//         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.003f)); // 非常低的透明度
        
//         java.util.Random random = new java.util.Random();
//         for (int i = 0; i < width * height / 100; i++) { // 添加一些随机点
//             int x = random.nextInt(width);
//             int y = random.nextInt(height);
//             int rgb = random.nextInt(256);
//             g2d.setColor(new Color(rgb, rgb, rgb));
//             g2d.fillRect(x, y, 1, 1);
//         }
//     }

//     /**
//      * 自定义MultipartFile实现，用于封装处理后的图片数据
//      */
//     private static class EnhancedMultipartFile implements MultipartFile {
//         private final byte[] content;
//         private final String name;
//         private final String originalFilename;
//         private final String contentType;

//         public EnhancedMultipartFile(byte[] content, String name, String originalFilename, String contentType) {
//             this.content = content;
//             this.name = name;
//             this.originalFilename = originalFilename;
//             this.contentType = contentType;
//         }

//         @Override
//         public String getName() {
//             return this.name;
//         }

//         @Override
//         public String getOriginalFilename() {
//             return this.originalFilename;
//         }

//         @Override
//         public String getContentType() {
//             return this.contentType;
//         }

//         @Override
//         public boolean isEmpty() {
//             return this.content.length == 0;
//         }

//         @Override
//         public long getSize() {
//             return this.content.length;
//         }

//         @Override
//         public byte[] getBytes() throws IOException {
//             return this.content;
//         }

//         @Override
//         public InputStream getInputStream() throws IOException {
//             return new ByteArrayInputStream(this.content);
//         }

//         @Override
//         public void transferTo(File dest) throws IOException, IllegalStateException {
//             try (FileOutputStream fos = new FileOutputStream(dest)) {
//                 fos.write(this.content);
//             }
//         }
//     }

//     // 判断是否为图片文件
//     private boolean isImageFile(String contentType) {
//         return contentType.startsWith("image/") &&
//                 (contentType.endsWith("jpeg") ||
//                         contentType.endsWith("png") ||
//                         contentType.endsWith("gif") ||
//                         contentType.endsWith("webp") ||
//                         contentType.endsWith("bmp"));
//     }

//     // 判断是否为视频文件
//     private boolean isVideoFile(String contentType) {
//         return contentType.startsWith("video/") &&
//                 (contentType.endsWith("mp4") ||
//                         contentType.endsWith("webm") ||
//                         contentType.endsWith("ogg") ||
//                         contentType.endsWith("quicktime") ||
//                         contentType.endsWith("x-msvideo"));
//     }

//     private boolean isImageSafe(String imageUrl) {
//         // 创建DefaultProfile实例
//         DefaultProfile profile = DefaultProfile.getProfile(
//                 "cn-beijing",  // 地域ID
//                 greenAccessKeyId,     // AccessKey ID
//                 greenAccessKeySecret  // AccessKey Secret
//         );
//         // 添加endpoint
//         DefaultProfile.addEndpoint("cn-beijing", "Green", "green.cn-beijing.aliyuncs.com");
//         // 创建IAcsClient实例
//         IAcsClient client = new DefaultAcsClient(profile);

//         try {
//             // 创建同步扫描请求
//             ImageSyncScanRequest imageSyncScanRequest = new ImageSyncScanRequest();
//             imageSyncScanRequest.setAcceptFormat(FormatType.JSON);
//             imageSyncScanRequest.setMethod(MethodType.POST);
//             imageSyncScanRequest.setEncoding("utf-8");
//             imageSyncScanRequest.setProtocol(ProtocolType.HTTP);

//             // 构建请求体
//             JSONObject httpBody = new JSONObject();
//             // 设置要检测的场景，根据需要添加或删除场景
//             httpBody.put("scenes", Arrays.asList(
//                     "porn",      // 鉴黄
//                     "terrorism", // 暴恐涉政
//                     "ad",        // 广告
//                     "qrcode",    // 二维码
//                     "live",      // 不良场景
//                     "logo"       // 商标台标
//             ));

//             // 设置待检测图片
//             JSONObject task = new JSONObject();
//             task.put("dataId", UUID.randomUUID().toString());
//             task.put("url", imageUrl);
//             task.put("time", new Date());
//             httpBody.put("tasks", Arrays.asList(task));

//             // 设置请求内容
//             imageSyncScanRequest.setHttpContent(
//                     org.apache.commons.codec.binary.StringUtils.getBytesUtf8(httpBody.toJSONString()),
//                     "UTF-8",
//                     FormatType.JSON
//             );
//             // 设置超时时间
//             imageSyncScanRequest.setConnectTimeout(connectTimeout);
//             imageSyncScanRequest.setReadTimeout(readTimeout);

//             // 调用服务端进行图片审核
//             HttpResponse httpResponse = client.doAction(imageSyncScanRequest);

//             // 处理响应结果
//             if (httpResponse.isSuccess()) {
//                 JSONObject scrResponse = JSON.parseObject(new String(httpResponse.getHttpContent(), "UTF-8"));
//                 JSONArray taskResults = scrResponse.getJSONArray("data");

//                 if (taskResults != null && !taskResults.isEmpty()) {
//                     JSONObject taskResult = taskResults.getJSONObject(0);
//                     // 这里不应该把200当作错误，200是正常的响应码
//                     if (taskResult.getInteger("code") == 200) {
//                         JSONArray sceneResults = taskResult.getJSONArray("results");
//                         // 遍历每个场景的检测结果
//                         for (int i = 0; i < sceneResults.size(); i++) {
//                             JSONObject sceneResult = sceneResults.getJSONObject(i);
//                             String suggestion = sceneResult.getString("suggestion");
//                             // 只有当建议为block时才记录警告日志
//                             if ("block".equals(suggestion)) {
//                                 log.warn("图片审核不通过，场景: {}, 建议: {}",
//                                         sceneResult.getString("scene"),
//                                         suggestion);
//                                 return false;
//                             }
//                         }
//                         // 所有场景都通过审核
//                         log.info("图片审核通过");
//                         return true;
//                     } else {
//                         // 非200状态码才是真正的错误
//                         log.error("图片审核服务响应异常，状态码: {}", taskResult.getInteger("code"));
//                         return false;
//                     }
//                 }
//             }
//             // 如果请求失败或解析响应失败，为安全起见返回false
//             log.error("图片审核请求失败: {}", httpResponse.getStatus());
//             return false;
//         } catch (Exception e) {
//             log.error("图片审核异常", e);
//             return false;
//         }
//     }

//     private String generateUniqueFileName(String originalFilename) {
//         String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
//         return UUID.randomUUID().toString() + extension;
//     }

//     private boolean isValidImageType(String contentType) {
//         return isImageFile(contentType) || isVideoFile(contentType);
//     }
// }